# 定义二叉树节点类
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


# 递归函数 judge，用于判断以 x 和 y 为根节点的两棵子树是否对称
def judge(x, y):
    # 如果 x 和 y 都为 None，说明这两棵子树都为空，是对称的，返回 True
    if x is None and y is None:
        return True
    # 如果 x 和 y 其中一个为 None，或者它们的值不相等，说明这两棵子树不对称，返回 False
    if x is None or y is None or x.val != y.val:
        return False
    # 递归判断 x 的左子树和 y 的右子树是否对称，以及 x 的右子树和 y 的左子树是否对称
    return judge(x.left, y.right) and judge(x.right, y.left)


# 递归 dfs，计算以 root 为根节点的子树的节点数量
def dfs(root):
    # 如果根节点为 None，说明该子树为空，节点数量为 0，返回 0
    if root is None:
        return 0
    # 初始化节点数量为 1，即根节点本身
    k = 1
    # 递归计算左子树的节点数量并累加到 k 中
    k += dfs(root.left)
    # 递归计算右子树的节点数量并累加到 k 中
    k += dfs(root.right)
    # 返回以 root 为根节点的子树的节点数量
    return k


# 构建二叉树
def build_tree(n, values, left_indices, right_indices):
    nodes = [None] * (n + 1)
    # 先创建所有节点
    for i in range(1, n + 1):
        nodes[i] = TreeNode(values[i - 1])
    # 再根据左右子节点索引连接节点
    for i in range(1, n + 1):
        left_index = left_indices[i - 1]
        right_index = right_indices[i - 1]
        if left_index != -1:
            nodes[i].left = nodes[left_index + 1]
        if right_index != -1:
            nodes[i].right = nodes[right_index + 1]
    return nodes[1]


n = int(input())
# 读取节点的值
values = list(map(int, input().split()))
left_indices = []
right_indices = []
# 读取每个节点的左子节点索引和右子节点索引
for i in range(n):
    left, right = map(int, input().split())
    left_indices.append(left)
    right_indices.append(right)

# 构建二叉树
root = build_tree(n, values, left_indices, right_indices)

ans = -1
# 遍历每个节点（这里简化为从根节点开始判断，因为以任意节点为根的子树都包含在其中）
for i in range(1, n + 1):
    # 调用 judge 函数判断该节点的左子树和右子树是否对称
    is_symmetric = judge(root.left, root.right)
    # 如果对称
    if is_symmetric:
        # dfs 计算以该节点为根节点的子树的节点数量，并更新最大对称子树的节点数量
        ans = max(ans, dfs(root))

# 输出最大对称子树的节点数量
print(ans)
#         1
#        / \
#       2   2
#      / \ / \
#     3  4 4  3